/**
 * File:   Mot.cpp
 * Author: CHABOT DIEP MYCEK
 *
 */
 
#include <iostream>
#include <string>
#include <fstream>
#include<string.h>
#include <sstream>
#include "Mot.hpp"
 
using namespace std;
 
Mot::Mot(){
	ligne = 0;
	colonne = 0;
	nbLettres = 0;
	vertical = false;
	nbCasesRemplies = 0;
	// $ symbolise que le mot est vide. Indispensable pour le chargement de la grille
	mot = "$";
	def = "$";
	fichier=""; 
}

void Mot::init(int x, int y, int lg, bool vert,string nomFich){
	ligne = x;
	colonne = y;
	nbLettres = lg;
	vertical = vert;
	nbCasesRemplies = 0;
	mot = "$";
	def = "$";
	fichier=nomFich; 
	string source;    
    ostringstream os;
    if(fichier!=""){
    	fichier = "possibles/"+fichier;
		os << lg;
		
		source="mots/mots_"+os.str()+".txt";
		copierFichier(source.c_str(),fichier.c_str());
		stockerDansList(fichier); 
		copierDansListTrav();
    }
}

void Mot::setMot(string m){
	mot = m;
	nbCasesRemplies = nbLettres;
}

int Mot::getLigne(){
	return ligne;
}

int Mot::getColonne(){
	return colonne;
}

int Mot::getNbLettres(){
	return nbLettres;
}

bool Mot::getVertical(){
	return vertical;
}

string Mot::getMot(){
	return mot;
}

string Mot::getDef(){
	return def;
}

void Mot::setDef(string d){
	def = d;
}

bool Mot::contient(int x, int y, bool vert){
	if(vert){
		if(vertical && y==colonne && x>=ligne && x<ligne+nbLettres){
			return true;
		}
		else return false;
	}
	else{
		if(!vertical && x==ligne && y>=colonne && y<colonne+nbLettres){
			return true;
		}
		else return false;
	}
}

int Mot::contient(int x, int y){
    int res=0; 
    if(vertical)
    {
        if(y==colonne && x>=ligne && x<ligne+nbLettres){res= x-ligne+1;}
    }
     else
     {  
         if(x==ligne && y>=colonne && y<colonne+nbLettres)  {res=y-colonne+1;}
     }
     return res; 
}

void Mot::setNbCasesRemplies(int nb){
	nbCasesRemplies = nb;
}

void Mot::augNbCasesRemplies(int delta){
	nbCasesRemplies+=delta;
}

int Mot::getNbCasesRemplies(){
	return nbCasesRemplies;
}

bool Mot::estRempli(){
	if(nbCasesRemplies == nbLettres) return true;
	else return false;
}

void Mot::reinitialiser(){
	mot="$";
	setNbCasesRemplies(0);
	stockerDansList(fichier); 
	copierDansListTrav();
}

void Mot::eliminerMot(int numero)
{
  list<string>::iterator it=sauv.begin();
  int compt=1; 
  while(it!=sauv.end() && numero != compt)
  {
    it++; 
    compt++;
  }
  if(numero==compt)
  { 
     it=pos.erase(it); 
  }
}

void Mot::eliminerMotFich()
{
  fstream fe,fo;
  fe.open(fichier.c_str(),fstream::in); 
  fo.open("buf.txt",fstream::out|fstream::trunc); 
  int compt=0; 
   while(!fe.eof())
   {
    compt++; 
    string texte; 
    fe>>texte;
     if(!texte.empty() && texte!=mot)
     { fo<<texte<<endl;} 
   }
   fe.close();
   fo.close(); 
  copierFichier("buf.txt",fichier.c_str()); 
}



bool Mot::motNumero(int n, string& res)
{
  int compt=0; 
  bool ok=true;
  if( n>0 && sauv.size()>= n )
  { 
      for (list<string>::iterator it=sauv.begin(); it!=sauv.end(); ++it)
      {
          compt++;
          if(compt==n)
          {
             res=*it;
          } 
      }
  
  }
  else {ok=false;}
  return ok;      
}

 
int Mot::getNombrePosListSauv()
{
    return (int) sauv.size(); 
}

int Mot::getNombrePosListTrav()
{
    return (int) pos.size(); 
}
 
 

void Mot::copierFichier(const char * entree,const char * sortie)
{
  fstream fe,fo;
  fe.open(entree,fstream::in); 
  fo.open(sortie,fstream::out|fstream::trunc); 
   while(!fe.eof())
   {
    string texte; 
    fe >> texte;
     if(!texte.empty())
     { fo<<texte<<endl;}
   }
   fe.close();
   fo.close(); 
}


bool Mot::fichierVide()
{
 bool res=true; 
 fstream fe; 
 string temp; 
 fe.open(fichier.c_str(),fstream::in); 
 while (res && !fe.eof())
  {
      fe>>temp;
      if(!temp.empty())
      {
        res=false; 
      }
  }
 return res;      
}

void Mot::stockerDansList(string nomFich)
   {
     sauv.clear(); 
     fstream fe; 
     fe.open(nomFich.c_str(),fstream::in); 
     while( !fe.eof())
       {
        string temp; 
        fe>>temp;
        if(!temp.empty())
          {
           sauv.push_back(temp);
          }
       }
   }
 
void Mot::stockerDansListTrav(string nomFich)
   {
     pos.clear(); 
     fstream fe; 
     fe.open(nomFich.c_str(),fstream::in); 
     while( !fe.eof())
       {
        string temp; 
        fe>>temp;
        if(!temp.empty())
          {
           pos.push_back(temp);
          }
       }
   } 
   
   
void Mot::copierDansListTrav()
   {
     pos.clear(); 
     for (list<string>::iterator it=sauv.begin(); it!=sauv.end(); ++it)
       {
           pos.push_back(*it);
       }
   }
   
void Mot::copierDansListSauv()
   {
     sauv.clear(); 
     for (list<string>::iterator it=pos.begin(); it!=pos.end(); ++it)
       {
           sauv.push_back(*it);
       }
   }
  
  
   
void Mot::filtreVeutList(char lettre,int position)
{
     position=position-1;
     if(position >=0 && position<nbLettres)
     {
          for (list<string>::iterator it=pos.begin(); it!=pos.end(); ++it)
           {
              string temp; 
             temp=*it; 
             if(!temp.empty() && temp[position]!=lettre)
             {
               it=pos.erase(it); 
                it--; 
             }
         } 
     }
     else { cerr<<"Pas une position realisable"<<endl; }
}


void Mot::filtreVeutPasList(string tab, int position)
 {
   position=position-1; 
   if(position >=0 && position<nbLettres)
     {
       for (list<string>::iterator it=pos.begin(); it!=pos.end(); ++it)
         {
             string temp; 
             temp=*it; 
             if(!temp.empty())
             {
               size_t found; 
               found=tab.find(temp[position]);   
               if(found!=string::npos)
               {
                  it =pos.erase(it) ;               
                  it--;
               }
             }
         }
     }
       else { cerr<<"Pas une position realisable"<<endl; }
 }
   
 
void Mot::aPasList(int position,char * tab,int *nb)
{
    
     int a; 
     char Interne[26]; 
     for(int i=0;i<26;i++){Interne[i]=0;}
     const char * tampon; 
     *nb=0; 
     position=position-1;
     if(position>=0 && position<nbLettres)
     {
         for (list<string>::iterator it=pos.begin(); it!=pos.end(); ++it)
         {
              string test; 
              test=*it;
              if(!test.empty())
               {
                tampon=test.c_str(); 
                a=tampon[position]-65;
                Interne[a]=tampon[position]; 
              }
         }
         for(int i=0;i<26;i++)
         {
                 if(Interne[i]==0)
                 {
                 tab[*nb]=(i+65);
                 *nb=*nb+1;
                 }
         }
     }
       else { cerr<<"Pas une position realisable"<<endl; }
}

void Mot::testMot(string m)
{
     pos.clear(); 
     pos.push_back(m); 
}
